package io.github.echarts.model.theme.provider;

import io.github.echarts.model.context.ConfigurationContext;
import io.github.echarts.model.theme.AbstractDefaultValueProvider;
import io.github.echarts.model.theme.Theme;
import io.github.echarts.option.component.Axis;
import io.github.echarts.option.component.axis.AxisLabel;
import io.github.echarts.option.component.axis.AxisLine;
import io.github.echarts.option.component.axis.AxisTick;
import io.github.echarts.option.component.axis.SplitLine;
import io.github.echarts.option.style.LineStyle;
import io.github.echarts.option.style.TextStyle;

import java.lang.reflect.Array;
import java.util.List;

/**
 * 坐标轴默认值提供者
 * <p>
 * 为坐标轴提供默认配置，包括轴线、刻度、标签等样式。
 * 根据不同轴类型和上下文应用不同的默认配置。
 * </p>
 */
public class AxisDefaultValueProvider extends AbstractDefaultValueProvider<Axis> {
    
    /**
     * 构造函数
     */
    public AxisDefaultValueProvider() {
        super(Axis.class);
    }
    
    @Override
    protected void initDefaultValues() {
        // 基本属性
        registerDefaultValue("show", true);
        registerDefaultValue("position", "bottom"); // 默认位置，X轴在底部，Y轴在左侧
        registerDefaultValue("type", "value");      // 默认为数值轴
        registerDefaultValue("scale", false);       // 默认不缩放到0值
        registerDefaultValue("silent", false);      // 默认响应交互
    }
    
    @Override
    public void applyDefaults(Axis axis, ConfigurationContext context) {
        super.applyDefaults(axis, context);
        
        // 为轴线添加默认配置
        if (axis.getAxisLine() == null) {
            AxisLine axisLine = new AxisLine();
            axisLine.setShow(true);
            axis.setAxisLine(axisLine);
        }
        
        // 为刻度添加默认配置
        if (axis.getAxisTick() == null) {
            AxisTick axisTick = new AxisTick();
            axisTick.setShow(true);
            axisTick.setAlignWithLabel(true);
            axis.setAxisTick(axisTick);
        }
        
        // 为标签添加默认配置
        if (axis.getAxisLabel() == null) {
            AxisLabel axisLabel = new AxisLabel();
            axisLabel.setShow(true);
            axisLabel.setInterval("auto");
            axis.setAxisLabel(axisLabel);
        }
        
        // 为分隔线添加默认配置
        if (axis.getSplitLine() == null) {
            SplitLine splitLine = new SplitLine();
            splitLine.setShow("category".equals(axis.getType()) ? false : true);
            axis.setSplitLine(splitLine);
        }
    }
    
    /**
     * 获取对象的长度(如果是数组或集合)
     * 
     * @param obj 要检查的对象
     * @return 长度，如果不是数组或集合则返回0
     */
    private int getObjectLength(Object obj) {
        if (obj == null) {
            return 0;
        }
        
        if (obj.getClass().isArray()) {
            return Array.getLength(obj);
        }
        
        if (obj instanceof List) {
            return ((List<?>) obj).size();
        }
        
        return 0;
    }
    
    @Override
    protected void applyDataDrivenDefaults(Axis axis, ConfigurationContext context) {
        // 根据数据特征调整坐标轴配置
        
        if (context == null) {
            return;
        }
        
        // 处理值轴
        if ("value".equals(axis.getType())) {
            ConfigurationContext.DataStatistics dataStats = context.getDataStatistics();
            
            // 注释掉未定义的getInterval和setInterval方法调用
            /*
            // 设置刻度间隔
            if (axis.getInterval() == null && dataStats != null) {
                Double max = dataStats.getMax();
                Double min = dataStats.getMin();
                
                if (max != null && min != null) {
                    double range = max - min;
                    int desiredTickCount = 5; // 理想的刻度数量
                    double interval = range / desiredTickCount;
                    
                    // 四舍五入到一个合适的刻度间隔
                    double magnitude = Math.pow(10, Math.floor(Math.log10(interval)));
                    double normalizedInterval = interval / magnitude;
                    
                    if (normalizedInterval < 2) {
                        interval = magnitude;
                    } else if (normalizedInterval < 5) {
                        interval = 2 * magnitude;
                    } else {
                        interval = 5 * magnitude;
                    }
                    
                    axis.setInterval(interval);
                }
            }
            */
            
            // 设置格式化器
            if (axis.getAxisLabel() != null && axis.getAxisLabel().getFormatter() == null) {
                String formatter = "{value}";
                
                // 根据数据特性调整格式化器
                ConfigurationContext.DataStatistics stats = context.getDataStatistics();
                if (stats != null) {
                    double avg = stats.getAverage();
                    int dataPrecision = 0;
                    
                    // 根据平均值确定显示精度
                    if (avg != 0 && Math.abs(avg) < 0.1) {
                        dataPrecision = 2;
                    } else if (avg != 0 && Math.abs(avg) < 1) {
                        dataPrecision = 1;
                    }
                    
                    if (avg > 10000) {
                        formatter = "{value}";
                    } else if (dataPrecision > 0) {
                        formatter = "{value:." + dataPrecision + "f}";
                    }
                    axis.getAxisLabel().setFormatter(formatter);
                }
            }
        }
        
        // 处理类目轴
        if ("category".equals(axis.getType())) {
            // 检查类目数量，决定是否旋转标签
            if (axis.getData() != null) {
                int categoryCount = getObjectLength(axis.getData());
                if (categoryCount > 12) {
                    // 类目过多时，旋转标签以避免重叠
                    if (axis.getAxisLabel() != null) {
                        axis.getAxisLabel().setRotate(45.0); // 使用Double类型
                        axis.getAxisLabel().setInterval(0);
                    }
                }
            }
        }
    }
    
    @Override
    public void ensureCompleteness(Axis axis, ConfigurationContext context) {
        // 确保轴线、刻度、标签对象的完整性
        if (axis.getAxisLine() != null && axis.getAxisLine().getLineStyle() == null) {
            axis.getAxisLine().setLineStyle(new LineStyle());
        }
        
        if (axis.getAxisTick() != null && axis.getAxisTick().getLineStyle() == null) {
            axis.getAxisTick().setLineStyle(new LineStyle());
        }
        
        if (axis.getAxisLabel() != null && axis.getAxisLabel().getTextStyle() == null) {
            axis.getAxisLabel().setTextStyle(new TextStyle());
        }
        
        if (axis.getSplitLine() != null && axis.getSplitLine().getLineStyle() == null) {
            axis.getSplitLine().setLineStyle(new LineStyle());
        }
    }
    
    @Override
    public void applyTheme(Axis axis, Theme theme) {
        if (axis == null || theme == null) {
            return;
        }
        
        // 应用轴线样式
        if (axis.getAxisLine() != null) {
            LineStyle axisLineStyle = axis.getAxisLine().getLineStyle();
            if (axisLineStyle == null) {
                axisLineStyle = new LineStyle();
                axis.getAxisLine().setLineStyle(axisLineStyle);
            }
            axisLineStyle.setColor(theme.getAxisLineColor());
        }
        
        // 应用轴刻度样式
        if (axis.getAxisTick() != null) {
            LineStyle axisTickStyle = axis.getAxisTick().getLineStyle();
            if (axisTickStyle == null) {
                axisTickStyle = new LineStyle();
                axis.getAxisTick().setLineStyle(axisTickStyle);
            }
            axisTickStyle.setColor(theme.getAxisLineColor());
        }
        
        // 应用轴标签样式
        if (axis.getAxisLabel() != null) {
            TextStyle axisLabelStyle = axis.getAxisLabel().getTextStyle();
            if (axisLabelStyle == null) {
                axisLabelStyle = new TextStyle();
                axis.getAxisLabel().setTextStyle(axisLabelStyle);
            }
            TextStyle themeTextStyle = theme.getTextStyle();
            if (themeTextStyle != null) {
                if (axisLabelStyle.getColor() == null) {
                    axisLabelStyle.setColor(themeTextStyle.getColor());
                }
                if (axisLabelStyle.getFontFamily() == null) {
                    axisLabelStyle.setFontFamily(themeTextStyle.getFontFamily());
                }
                if (axisLabelStyle.getFontSize() == null) {
                    axisLabelStyle.setFontSize(themeTextStyle.getFontSize());
                }
                if (axisLabelStyle.getFontWeight() == null) {
                    axisLabelStyle.setFontWeight(themeTextStyle.getFontWeight());
                }
            }
        }
        
        // 应用分隔线样式
        if (axis.getSplitLine() != null) {
            LineStyle splitLineStyle = axis.getSplitLine().getLineStyle();
            if (splitLineStyle == null) {
                splitLineStyle = new LineStyle();
                axis.getSplitLine().setLineStyle(splitLineStyle);
            }
            splitLineStyle.setColor(theme.getSplitLineColor());
            splitLineStyle.setType("dashed");
            splitLineStyle.setWidth(1);
        }
    }
} 